﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using Sinacor.Infra.UI.Common;

namespace Sinacor.UI.Bovespa.Operador.Presenter
{
    public class CadastroOperador : BasePresenter<ICadastroOperador>
    {
        private Communication.Operador _communicOperador;
        private Communication.Usuario _communicUsuario;

        #region Models

        public ModelCollection<Model.Usuario> ListaUsuarios
        {
            get;
            private set;
        }

        public ModelCollection<Model.Operador> ListaOperadores
        {
            get;
            private set;
        }

        public ModelCollection<Model.Operador> ListaSubordinados
        {
            get;
            private set;
        }               

        public ModelCollection<Model.Origem> ListaOrigem
        {
            get;
            private set;
        }

        public Model.Origem OrigemAnterior { get; set; }

        #endregion

        #region Construtor

        public CadastroOperador(ICadastroOperador CadastroOperador)
            : base(CadastroOperador)
        {
            this._communicOperador = new Communication.Operador(this.Session);
            this._communicUsuario = new Communication.Usuario(this.Session);

            this.ListaUsuarios = new ModelCollection<Model.Usuario>();
            this.ListaOperadores = new ModelCollection<Model.Operador>();
            this.ListaSubordinados = new ModelCollection<Model.Operador>();
            this.ListaOrigem = new ModelCollection<Model.Origem>();
        }

        #endregion

        #region Inicializar

        public void Inicializar()
        {
            // Carrega a lista de usuários
            this.ConsultarUsuarios();

            // Carrega a lista de operadores
            this.ListaOperadores = this.ConsultarOperadores();
            if (this.ListaOperadores.Count == 0)
                this.View.InformarNenhumOperadorEncontrado();
            else
                this.View.AtualizarOperadores();

            // Verifica se é Kernel+
            this.View.ValidarFuncionalidadeOrigem();
        }

        #endregion

        #region ConsultarUsuarios

        public void ConsultarUsuarios()
        {
            try
            {
                this.ListaUsuarios = this._communicUsuario.ConsultarUsuarios(new Model.Parameter.FiltroUsuario { Operador = false, Bloqueado = false });

                if (this.ListaUsuarios.Count == 0)
                    this.View.InformarNenhumUsuarioEncontrado();
                else
                    this.View.AtualizarUsuarios();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        #endregion

        #region ConsultarOperadores

        private ModelCollection<Model.Operador> ConsultarOperadores()
        {
            ModelCollection<Model.Operador> operadores = null;

            try
            {
                 operadores = this._communicOperador.ConsultarOperadores
                                (
                                    new Model.Parameter.FiltroOperador
                                    {
                                        CodigoOperador = null,
                                        CodigoOperadorMegaBolsa = null,
                                        CodigoOperadorRendaFixa = null,
                                        IndicadorDesprezaOperadorSinalOfertasMegaBolsa = null,
                                        IndicadorOperadorHomeBroker = null,
                                        IndicadorPontaMesa = null,
                                        LoginOperador = null,
                                        NomeOperador = null,
                                        Bloqueado = null
                                    }
                                );
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }

            return operadores;
        }

        #endregion

        #region ConsultarSubordinados

        public void ConsultarSubordinados(Model.Operador request)
        {
            try
            {
                this.ListaSubordinados = this._communicOperador.ConsultarIdentificacaoSubordinados(new Model.Parameter.FiltroCodigoOperador { Valor = request.CodigoOperador.Value });

                this.View.AtualizarSubordinados();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        #endregion

        #region VerificarSubordinado

        public Boolean VerificarSubordinado(Model.Operador request)
        {
            try
            {
                return request.Subordinado;
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
                return false;
            }
        }

        #endregion

        #region ConsultarCorretorasRelacionadas

        public void ConsultarCorretorasRelacionadas(Model.Parameter.FiltroCodigoOperador request)
        {
            try
            {
                this.ListaOrigem = this._communicOperador.ConsultarCorretorasRelacionadas(request);

                this.View.AtualizarOrigem();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        #endregion

        #region IncluirOperadores

        public void IncluirOperadores(ModelCollection<Model.Usuario> request)
        {
            try
            {
                if (request.Count == 0)
                    this.View.InformarNenhumUsuarioSelecionado();
                else
                {
                    ModelCollection<Model.Operador> operadores = new ModelCollection<Model.Operador>();

                    foreach (Model.Usuario item in request)
                    {
                        operadores.Add(new Model.Operador
                                       {
                                           CodigoOperador = item.Codigo,
                                           CodigoOperadorMegaBolsa = null,
                                           CodigoOperadorRendaFixa = null,
                                           IndicadorDesprezaOperadorSinalOfertasMegaBolsa = false,
                                           IndicadorOperadorHomeBroker = false,
                                           IndicadorPontaMesa = false
                                       });
                    }

                    this._communicOperador.IncluirOperadores(operadores);
                    
                    // Atualiza o DataGrid de Operadores
                    this.AtualizarOperadores();

                    // Atualiza o DataGrid de Usuários
                    this.ConsultarUsuarios();

                    // Limpa o DataGrid de Subordinados
                    this.LimparSubordinados();

                    // Limpa o DataGrid de Origem
                    this.LimparOrigem();

                    this.View.InformarOperadorIncluidoSucesso();
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        #endregion

        #region AlterarOperador

        public Boolean AlterarOperador(Model.Operador request)
        {
            Boolean result = false;

            try
            {
                if (this.View.ConfirmarAlteracaoOperador())
                {
                    this._communicOperador.AlterarOperador(request);

                    this.View.InformarOperadorAtualizadoSucesso();

                    result = true;
                }

                return result;
            }
            catch (Exception ex)
            {
                base.HandleException(ex);

                return false;
            }
        }

        #endregion

        #region ExcluirOperadores

        public Boolean ExcluirOperadores(ModelCollection<Model.Operador> request, Boolean kernel)
        {
            Boolean result = false;

            try
            {
                if (request.Count == 0)
                    this.View.InformarNenhumOperadorSelecionado();
                else
                {
                    if (this.View.ConfirmarExclusaoOperador())
                    {
                        ModelCollection<Model.Parameter.FiltroCodigoOperador> listaFiltroCodigoOperador = new ModelCollection<Model.Parameter.FiltroCodigoOperador>();
                        foreach (Model.Operador item in request)
                            listaFiltroCodigoOperador.Add(new Model.Parameter.FiltroCodigoOperador { Valor = item.CodigoOperador.Value, Kernel = kernel });

                        this._communicOperador.ExcluirOperadores(listaFiltroCodigoOperador);

                        this.AtualizarDadosExclusaoOperador();

                        this.View.InformarOperadorExcluidoSucesso();

                        result = true;
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                this.AtualizarDadosExclusaoOperador();                

                base.HandleException(ex);
                
                return false;
            }
        }

        private void AtualizarDadosExclusaoOperador()
        {
            // Atualiza a DataGrid de Usuários
            this.ConsultarUsuarios();

            // Atualiza a DataGrid de Operadores
            this.AtualizarOperadores();

            // Limpa o DataGrid de Subordinados
            this.LimparSubordinados();
        }

        #endregion

        #region AtualizarOperadores

        private void AtualizarOperadores()
        {
            this.ListaOperadores = this.ConsultarOperadores();
            this.View.AtualizarOperadores();
        }

        #endregion

        #region IncluirSubordinados

        public void IncluirSubordinados(Model.Operador operador, ModelCollection<Model.Operador> subordinados)
        {
            try
            {
                if (operador == null)
                    this.View.InformarNenhumOperadorSelecionadoSubordinado();
                else if (subordinados.Count == 0)
                    this.View.InformarNenhumSubordinadoSelecionadoInclusao();
                else
                {
                    List<Int32> listaSubordinados = new List<Int32>();
                    foreach (Model.Operador item in subordinados)
                        listaSubordinados.Add(item.CodigoOperador.Value);

                    this._communicOperador.IncluirSubordinados
                        (
                            new Model.OperadorXSubordinados
                            {
                                CodigoOperador = operador.CodigoOperador.Value,
                                Subordinados = listaSubordinados
                            }
                        );

                    this.ConsultarSubordinados(new Model.Operador() { CodigoOperador = operador.CodigoOperador });

                    this.View.InformarSubordinadoIncluidoSucesso();
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        #endregion

        #region ExcluirSubordinados

        public void ExcluirSubordinados(Model.Operador operador, ModelCollection<Model.Operador> subordinados)
        {
            try
            {
                if (subordinados.Count == 0)
                    this.View.InformarNenhumSubordinadoSelecionado();
                else
                {
                    if (this.View.ConfirmarExclusaoSubordinados())
                    {
                        List<Int32> listaSubordinados = new List<Int32>();
                        foreach (Model.Operador item in subordinados)
                            listaSubordinados.Add(item.CodigoOperador.Value);

                        this._communicOperador.ExcluirSubordinados
                            (
                                new Model.OperadorXSubordinados
                                {
                                    CodigoOperador = operador.CodigoOperador.Value,
                                    Subordinados = listaSubordinados
                                }
                            );

                        this.ConsultarSubordinados(new Model.Operador() { CodigoOperador = operador.CodigoOperador });

                        this.View.InformarSubordinadoExcluidoSucesso();
                    }
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        #endregion

        #region LimparSubordinados

        public void LimparSubordinados()
        {
            this.ListaSubordinados = new ModelCollection<Model.Operador>();
            this.View.AtualizarSubordinados();
        }

        #endregion

        #region LimparOrigem

        public void LimparOrigem()
        {
            this.ListaOrigem = new ModelCollection<Model.Origem>();
            this.View.AtualizarOrigem();
        }

        #endregion

        #region IncluirRelacaoCorretoraOperador

        public Boolean IncluirRelacaoCorretoraOperador(Model.Origem request)
        {
            Boolean result = false;
            try
            {
                this._communicOperador.IncluirRelacaoCorretoraOperador(request);

                this.View.InformarOrigemIncluidaSucesso();
                
                result = true;
            }
            catch (Exception ex)
            {
                result = false;
                base.HandleException(ex);
            }

            return result;
        }

        #endregion

        #region ExcluirRelacoesCorretoraOperador

        public Boolean ExcluirRelacoesCorretoraOperador(ModelCollection<Model.Origem> request)
        {
            Boolean result = false;
            try
            {
                this._communicOperador.ExcluirRelacoesCorretoraOperador(request);

                // Atualiza a DataGrid de origem
                if (request.Count > 0)
                    this.ConsultarCorretorasRelacionadas(new Model.Parameter.FiltroCodigoOperador() { Valor = request[0].OperadorReceptor });

                this.View.InformarOrigemExcluidaSucesso();

                result = true;
            }
            catch (Exception ex)
            {
                result = false;
                base.HandleException(ex);
            }

            return result;
        }

        #endregion

        #region AlterarRelacaoCorretoraOperador

        public Boolean AlterarRelacaoCorretoraOperador(Model.Origem request)
        {
            Boolean result = false;
            try
            {
                this._communicOperador.AlterarRelacaoCorretoraOperador
                    (
                        new Model.OrigemAnteriorAtual()
                            {
                                Anterior = this.OrigemAnterior,

                                Atual = new Model.Origem()
                                {
                                    Corretora = request.Corretora,
                                    OperadorOrigem = request.OperadorOrigem
                                }
                            }
                    );

                this.View.InformarOrigemExcluidaSucesso();

                result = true;
            }
            catch (Exception ex)
            {
                result = false;
                base.HandleException(ex);
            }

            return result;
        }

        #endregion
    }
}
